home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacApp Release 10 / MacApp Release 10 - HD Ready / Libraries / Framework / Sources / UEventHandler.cp < prev    next >
Encoding:
Text File  |  1996-04-03  |  30.0 KB  |  1,018 lines  |  [TEXT/MPS ]
  1. //----------------------------------------------------------------------------------------
  2. // UEventHandler.cp 
  3. // Copyright © 1984-96 by Apple Computer, Inc. All rights reserved.
  4. //----------------------------------------------------------------------------------------
  5.  
  6. #ifndef __UEVENTHANDLER__
  7. #include "UEventHandler.h"
  8. #endif
  9.  
  10. // MacApp
  11.  
  12. #ifndef __UBEHAVIOR__
  13. #include "UBehavior.h"
  14. #endif
  15.  
  16. #ifndef __UCOMMAND__
  17. #include "UCommand.h"
  18. #endif
  19.  
  20. #ifndef __UCOREGLOBALS__
  21. #include "UCoreGlobals.h"
  22. #endif
  23.  
  24. #ifndef __UCOREUTILITIES__
  25. #include "UCoreUtilities.h"
  26. #endif
  27.  
  28. #ifndef __UDEBUG__
  29. #include "UDebug.h"
  30. #endif
  31.  
  32. #ifndef __UDISPATCHER__
  33. #include "UDispatcher.h"
  34. #endif
  35.  
  36. #ifndef __UEVENT__
  37. #include "UEvent.h"
  38. #endif
  39.  
  40. #ifndef __UFAILURE__
  41. #include "UFailure.h"
  42. #endif
  43.  
  44. #ifndef __UGEOMETRY__
  45. #include "UGeometry.h"
  46. #endif
  47.  
  48. #ifndef __UMACAPPGLOBALS__
  49. #include "UMacAppGlobals.h"
  50. #endif
  51.  
  52. #ifndef __USTREAM__
  53. #include "UStream.h"
  54. #endif
  55.  
  56. // Toolbox
  57.  
  58. #ifndef __RESOURCES__
  59. #include <Resources.h>
  60. #endif
  61.  
  62. // ANSI
  63.  
  64. #ifndef __STDIO__
  65. #include <stdio.h>
  66. #endif
  67.  
  68. #ifndef __STDLIB__
  69. #include <stdlib.h>
  70. #endif
  71.  
  72.  
  73. //----------------------------------------------------------------------------------------
  74. // static data members
  75. //----------------------------------------------------------------------------------------
  76. CPoint TEventHandler::gStdHysteresis(4, 4);
  77.  
  78.  
  79. //========================================================================================
  80. // CLASS CHandlerIterator
  81. //========================================================================================
  82. #undef Inherited
  83. #define Inherited CIterator
  84.  
  85. //----------------------------------------------------------------------------------------
  86. // CHandlerIterator::Reset: 
  87. //----------------------------------------------------------------------------------------
  88. #pragma segment MAEvtHandlerRes
  89.  
  90. CHandlerIterator::CHandlerIterator(TEventHandler* chainHead)
  91. {
  92.     fFirstHandler = fCurrentHandler = chainHead;
  93.     // Retrieve next handler now since DoToEventHandler may free fCurrentHandler
  94.     if (chainHead)
  95.         fNextHandler = chainHead ? chainHead->GetNextHandler() : NULL;
  96. }
  97.  
  98. //----------------------------------------------------------------------------------------
  99. // CHandlerIterator::Reset: 
  100. //----------------------------------------------------------------------------------------
  101. #pragma segment MAEvtHandlerRes
  102.  
  103. TEventHandler* CHandlerIterator::FirstHandler()
  104. {
  105.     Reset();
  106.  
  107.     return fFirstHandler;
  108. }
  109.  
  110. //----------------------------------------------------------------------------------------
  111. // CHandlerIterator::Reset: 
  112. //----------------------------------------------------------------------------------------
  113. #pragma segment MAEvtHandlerRes
  114.  
  115. TEventHandler* CHandlerIterator::NextHandler()
  116. {
  117.     Advance();
  118.  
  119.     return fCurrentHandler;
  120. }
  121.  
  122. //----------------------------------------------------------------------------------------
  123. // CHandlerIterator::Advance: 
  124. //----------------------------------------------------------------------------------------
  125. #pragma segment MAEvtHandlerRes
  126.  
  127. void CHandlerIterator::Advance()
  128. {
  129.     fCurrentHandler = fNextHandler;
  130.     if (fCurrentHandler)
  131.         fNextHandler = fCurrentHandler->GetNextHandler();
  132. }
  133.  
  134.  
  135. //========================================================================================
  136. // CLASS TEventHandler
  137. //========================================================================================
  138. #undef Inherited
  139. #define Inherited TObject
  140.  
  141. #pragma segment MAEvtHandlerNonRes
  142. MA_DEFINE_CLASS_M1(TEventHandler,
  143.                    Inherited);
  144.  
  145. //----------------------------------------------------------------------------------------
  146. // TEventHandler constructor
  147. //----------------------------------------------------------------------------------------
  148. #pragma segment MAEvtHandlerRes
  149.  
  150. TEventHandler::TEventHandler() :
  151.     fNextHandler(NULL),
  152.     fBehavior(NULL),
  153.     fIdentifier(kNoIdentifier),
  154.     fIdleFreq(kMaxIdleTime),
  155.     // Assume it never wants idle time 
  156.     fLastIdle(0),
  157.     fEnabled(TRUE)                                // Default to taking events 
  158. {
  159. }
  160. // TEventHandler::TEventHandler
  161.  
  162. //----------------------------------------------------------------------------------------
  163. // TEventHandler::IEventHandler: 
  164. //----------------------------------------------------------------------------------------
  165. #pragma segment MAEvtHandlerRes
  166.  
  167. void TEventHandler::IEventHandler(TEventHandler* itsNextHandler)
  168. {
  169.     IObject();
  170.     fNextHandler = itsNextHandler;
  171. }
  172.  
  173. //----------------------------------------------------------------------------------------
  174. // TEventHandler::BecameWindowTarget: 
  175. //----------------------------------------------------------------------------------------
  176. #pragma segment MAEvtHandlerRes
  177.  
  178. void TEventHandler::BecameWindowTarget()
  179. {
  180. }
  181.  
  182. //----------------------------------------------------------------------------------------
  183. // TEventHandler::BecameTarget: 
  184. //----------------------------------------------------------------------------------------
  185. #pragma segment MAEvtHandlerRes
  186.  
  187. void TEventHandler::BecameTarget()
  188. {
  189.     HandleEvent(mBecameTarget, this, NULL);
  190. }
  191.  
  192. //----------------------------------------------------------------------------------------
  193. // TEventHandler::BecomeTarget: 
  194. //----------------------------------------------------------------------------------------
  195. #pragma segment MAEvtHandlerRes
  196.  
  197. Boolean TEventHandler::BecomeTarget()
  198. {
  199.     Boolean returnVal = FALSE;
  200.  
  201.     TEventHandler * currentTarget = gDispatcher->GetTarget();
  202.     if (this != currentTarget)
  203.     {
  204.         if (currentTarget->ResignTarget())
  205.         {
  206.             gDispatcher->SetTarget(this);
  207.             returnVal = TRUE;
  208.         }
  209.     }
  210.     else
  211.         returnVal = TRUE;
  212.  
  213.     return returnVal;
  214. }
  215.  
  216. //----------------------------------------------------------------------------------------
  217. // TEventHandler::ResignTarget: 
  218. //----------------------------------------------------------------------------------------
  219. #pragma segment MAEvtHandlerRes
  220.  
  221. Boolean TEventHandler::ResignTarget()
  222. {
  223.     Boolean returnVal = FALSE;
  224.  
  225.     TEventHandler * currentTarget = gDispatcher->GetTarget();
  226.     long reason = currentTarget->WillingToResignTarget();
  227.  
  228.     if (reason == 0)
  229.     {
  230.         currentTarget->TargetValidationSucceeded();
  231.  
  232.         gDispatcher->SetTarget(gDispatcher);
  233.         returnVal = TRUE;
  234.     }
  235.     else
  236.         currentTarget->TargetValidationFailed(reason);
  237.  
  238.     return returnVal;
  239. }
  240.  
  241. //----------------------------------------------------------------------------------------
  242. // TEventHandler::SetEnable: 
  243. //----------------------------------------------------------------------------------------
  244. #pragma segment MAEvtHandlerRes
  245.  
  246. void TEventHandler::SetEnable(Boolean state)
  247. {
  248.     fEnabled = state;
  249. }
  250.  
  251. //----------------------------------------------------------------------------------------
  252. // TEventHandler::Free: 
  253. //----------------------------------------------------------------------------------------
  254. #pragma segment MAClose
  255.  
  256. TEventHandler::~TEventHandler()
  257. {
  258.     if ((gDispatcher != NULL) && (gDispatcher != this) && (gDispatcher->GetTarget() == this))
  259.     {
  260.         if (GetNextHandler())
  261.             gDispatcher->SetTarget(GetNextHandler());
  262.         else
  263.             gDispatcher->SetTarget(gDispatcher);
  264.     }
  265.     fNextHandler = NULL;
  266.  
  267.     fBehavior = (TBehavior *)FreeIfObject(fBehavior);
  268. }
  269.  
  270. //----------------------------------------------------------------------------------------
  271. // TEventHandler::Clone: 
  272. //----------------------------------------------------------------------------------------
  273. #pragma segment MANonRes
  274.  
  275. TObject* TEventHandler::Clone()
  276. {
  277.     MAVolatileInit(TEventHandler * , aClonedEventHandler, (TEventHandler *)(Inherited::Clone()));
  278.  
  279.     // since we "own" our behaviors, let's clone 'em too!
  280.     aClonedEventHandler->fBehavior = NULL;        // remove reference to behaviors
  281.  
  282.     FailInfo fi;
  283.     Try(fi)
  284.     {
  285.         CBehaviorIterator iter(this);
  286.  
  287.         for (TBehavior * aBehavior = iter.FirstBehavior(); iter.More(); aBehavior = iter.NextBehavior())
  288.         {
  289.             TBehavior * aClonedBehavior = (TBehavior *)aBehavior->Clone();
  290.             aClonedEventHandler->AddBehavior(aClonedBehavior);
  291.         }
  292.         fi.Success();
  293.     }
  294.     else                                        // Recover
  295.     {
  296.         aClonedEventHandler->Free();
  297.         fi.ReSignal();
  298.     }
  299.  
  300.     return aClonedEventHandler;
  301. }
  302.  
  303. //----------------------------------------------------------------------------------------
  304. // TEventHandler::AddHandler: 
  305. //----------------------------------------------------------------------------------------
  306. #pragma segment MANonRes
  307.  
  308. TEventHandler* TEventHandler::AddHandler(TEventHandler* headOfChain)
  309. {
  310.     // add headOfChain to the end of the chain 
  311.     if (fNextHandler != NULL)
  312.         fNextHandler->AddHandler(headOfChain);
  313.     else
  314.         fNextHandler = headOfChain;
  315.     return this;                                // new head of chain 
  316. }
  317.  
  318. //----------------------------------------------------------------------------------------
  319. // TEventHandler::RemoveHandler: 
  320. //----------------------------------------------------------------------------------------
  321. #pragma segment MANonRes
  322.  
  323. TEventHandler* TEventHandler::RemoveHandler(TEventHandler* headOfChain)
  324. {
  325.     TEventHandler * prevCohandler;
  326.     TEventHandler * currCohandler;
  327.     TEventHandler * newHeadOfChain;
  328.  
  329.     prevCohandler = NULL;
  330.     currCohandler = headOfChain;
  331.     newHeadOfChain = headOfChain;
  332.     while (currCohandler != NULL)
  333.     {
  334.         if (currCohandler == this)                // found it 
  335.         {
  336.             if (prevCohandler == NULL)            // I was the head of the chain, so there
  337.             // will be a new head of chain
  338.                 newHeadOfChain = fNextHandler;
  339.             else
  340.                 prevCohandler->fNextHandler = fNextHandler;// take me out of the link 
  341.             fNextHandler = NULL;                // remember that i'm not in the chain
  342.             // anymore
  343.             currCohandler = NULL;                // So loop will end 
  344.         }
  345.         else
  346.         {
  347.             prevCohandler = currCohandler;
  348.             currCohandler = currCohandler->fNextHandler;
  349.         }
  350.     }
  351.  
  352.     return newHeadOfChain;
  353. }
  354.  
  355. //----------------------------------------------------------------------------------------
  356. // TEventHandler::DoCommandKeyEvent: 
  357. //----------------------------------------------------------------------------------------
  358. #pragma segment MAEvtHandlerRes
  359.  
  360. void TEventHandler::DoCommandKeyEvent(TToolboxEvent* event)
  361. {
  362.     if (GetNextHandler())
  363.         GetNextHandler()->HandleCommandKey(event);
  364. }
  365.  
  366. //----------------------------------------------------------------------------------------
  367. // TEventHandler::HandleCommandKey: 
  368. //----------------------------------------------------------------------------------------
  369. #pragma segment MAEvtHandlerRes
  370.  
  371. void TEventHandler::HandleCommandKey(TToolboxEvent* event)
  372. {
  373.     TBehavior * aBehavior = GetFirstEnabledBehavior();
  374.     if (aBehavior)
  375.         aBehavior->DoCommandKeyEvent(event);
  376.     else
  377.         DoCommandKeyEvent(event);
  378. }
  379.  
  380. //----------------------------------------------------------------------------------------
  381. // TEventHandler::DoCoHandlerEvent: 
  382. //----------------------------------------------------------------------------------------
  383. #pragma segment MAEvtHandlerRes
  384.  
  385. Boolean TEventHandler::DoCoHandlerEvent(TEvent*)
  386. {
  387.     return FALSE;
  388. }
  389.  
  390. //----------------------------------------------------------------------------------------
  391. // TEventHandler::DoHelp: 
  392. //----------------------------------------------------------------------------------------
  393. #pragma segment MAHelp
  394.  
  395. void TEventHandler::DoHelp(TToolboxEvent* event,
  396.                            long& message)
  397. {
  398.     if (GetNextHandler())
  399.         GetNextHandler()->DoHelp(event, message);
  400. }
  401.  
  402. //----------------------------------------------------------------------------------------
  403. // TEventHandler::NextIdle: 
  404. //----------------------------------------------------------------------------------------
  405. #pragma segment MAEvtHandlerRes
  406.  
  407. long TEventHandler::NextIdle()
  408. {
  409.     // first compute the next needed idle time based on myself
  410.     long returnVal;
  411.  
  412.     if ((fIdleFreq != kMaxIdleTime) && (IsEnabled()))// Does it idle at all? 
  413.     {
  414.         if (fLastIdle == 0)                        // if never idled then it needs idling now 
  415.             returnVal = TickCount();
  416.         else
  417.             returnVal = fLastIdle + fIdleFreq;
  418.     }
  419.     else
  420.         returnVal = kMaxIdleTime;
  421.  
  422.     // then bound it by the attached behaviors
  423.     CBehaviorIterator iter(this);
  424.  
  425.     for (TBehavior * aBehavior = iter.FirstBehavior(); iter.More(); aBehavior = iter.NextBehavior())
  426.         returnVal = Min(returnVal, aBehavior->NextIdle());
  427.  
  428.     return returnVal;
  429. }
  430.  
  431. //----------------------------------------------------------------------------------------
  432. // TEventHandler::HandleIdle: 
  433. //----------------------------------------------------------------------------------------
  434. #pragma segment MAEvtHandlerRes
  435.  
  436. void TEventHandler::HandleIdle(IdlePhase phase)
  437. {
  438.     TBehavior * aBehavior = GetFirstBehavior();
  439.     if (aBehavior)
  440.         aBehavior->HandleIdle(phase);
  441.  
  442.     if ((fIdleFreq != kMaxIdleTime) && IsEnabled())// Does it idle at all? 
  443.     {
  444.         // idleBegin and idleEnd don't respect fIdleFreq because they are notifications
  445.         // that the application is beginning/ ending idle. idleContinues, however, are
  446.         // parceled out at the fIdleFreq.
  447.         if ((phase != idleContinue) || (TickCount() - fLastIdle >= fIdleFreq))
  448.         {
  449.             // don't store the fLastIdle if I FREE'd myself or the idlePhase
  450.             // is not idleContinue
  451.             if (!(DoIdle(phase)) && (phase == idleContinue))
  452.                 fLastIdle = TickCount();
  453.         }
  454.     }
  455. }
  456.  
  457. //----------------------------------------------------------------------------------------
  458. // TEventHandler::DoIdle: 
  459. //----------------------------------------------------------------------------------------
  460. #pragma segment MAEvtHandlerRes
  461.  
  462. Boolean TEventHandler::DoIdle(IdlePhase)
  463. {
  464.     return FALSE;                                // Did not free myself 
  465. }
  466.  
  467. //----------------------------------------------------------------------------------------
  468. // TEventHandler::DoKeyEvent: 
  469. //----------------------------------------------------------------------------------------
  470. #pragma segment MAEvtHandlerRes
  471.  
  472. void TEventHandler::DoKeyEvent(TToolboxEvent* event)
  473. {
  474.     if (GetNextHandler())
  475.         GetNextHandler()->HandleKeyCommand(event);
  476. }
  477.  
  478. //----------------------------------------------------------------------------------------
  479. // TEventHandler::DoKeyUp: 
  480. //----------------------------------------------------------------------------------------
  481. #pragma segment MAEvtHandlerRes
  482.  
  483. void TEventHandler::DoKeyUp(TToolboxEvent* event)
  484. {
  485.     if (GetNextHandler())
  486.         GetNextHandler()->HandleKeyUp(event);
  487. }
  488.  
  489. //----------------------------------------------------------------------------------------
  490. // TEventHandler::HandleKeyCommand: 
  491. //----------------------------------------------------------------------------------------
  492. #pragma segment MAEvtHandlerRes
  493.  
  494. void TEventHandler::HandleKeyCommand(TToolboxEvent* event)
  495. {
  496.     TBehavior * aBehavior = GetFirstEnabledBehavior();
  497.     if (aBehavior)
  498.         aBehavior->DoKeyEvent(event);
  499.     else
  500.         DoKeyEvent(event);
  501. }
  502.  
  503. //----------------------------------------------------------------------------------------
  504. // TEventHandler::HandleKeyUp: 
  505. //----------------------------------------------------------------------------------------
  506. #pragma segment MAEvtHandlerRes
  507.  
  508. void TEventHandler::HandleKeyUp(TToolboxEvent* event)
  509. {
  510.     TBehavior * aBehavior = GetFirstEnabledBehavior();
  511.     if (aBehavior)
  512.         aBehavior->DoKeyUp(event);
  513.     else
  514.         DoKeyUp(event);
  515. }
  516.  
  517. //----------------------------------------------------------------------------------------
  518. // TEventHandler::DoMenuCommand: 
  519. //----------------------------------------------------------------------------------------
  520. #pragma segment MASelCommand
  521.  
  522. void TEventHandler::DoMenuCommand(CommandNumber aCommandNumber)
  523. {
  524.     if (GetNextHandler())
  525.         GetNextHandler()->HandleMenuCommand(aCommandNumber);
  526. #if qDebugMsg
  527.     else
  528.         fprintf(stderr, "No one handled the command %1d\n", aCommandNumber);
  529. #endif
  530. }
  531.  
  532. //----------------------------------------------------------------------------------------
  533. // TEventHandler::HandleMenuCommand: 
  534. //----------------------------------------------------------------------------------------
  535. #pragma segment MAEvtHandlerRes
  536.  
  537. void TEventHandler::HandleMenuCommand(CommandNumber aCommandNumber)
  538. {
  539.     TBehavior * aBehavior = GetFirstEnabledBehavior();
  540.     if (aBehavior)
  541.         aBehavior->DoMenuCommand(aCommandNumber);
  542.     else
  543.         DoMenuCommand(aCommandNumber);
  544.  
  545. }
  546.  
  547. //----------------------------------------------------------------------------------------
  548. // TEventHandler::DoMultiClick: 
  549. //----------------------------------------------------------------------------------------
  550. #pragma segment MAEvtHandlerRes
  551.  
  552. Boolean TEventHandler::DoMultiClick(CPoint lastDownPt,
  553.                                     CPoint newDownPt)
  554. {
  555.     return GetNextHandler() ? GetNextHandler()->DoMultiClick(lastDownPt, newDownPt) : 
  556.     (abs(lastDownPt.h - newDownPt.h) <= (gStdHysteresis.h)) && (abs(lastDownPt.v - newDownPt.v) <= (gStdHysteresis.v));
  557. }
  558.  
  559. //----------------------------------------------------------------------------------------
  560. // TEventHandler::DoSetupMenus: 
  561. //----------------------------------------------------------------------------------------
  562. #pragma segment MAEvtHandlerRes
  563.  
  564. void TEventHandler::DoSetupMenus()
  565. {
  566.     if (GetNextHandler())
  567.         GetNextHandler()->HandleSetupMenus();
  568. }
  569.  
  570. //----------------------------------------------------------------------------------------
  571. // TEventHandler::HandleSetupMenus: 
  572. //----------------------------------------------------------------------------------------
  573. #pragma segment MAEvtHandlerRes
  574.  
  575. void TEventHandler::HandleSetupMenus()
  576. {
  577.     TBehavior * aBehavior = GetFirstEnabledBehavior();
  578.     if (aBehavior)
  579.         aBehavior->DoSetupMenus();
  580.     else
  581.         DoSetupMenus();
  582. }
  583.  
  584. //----------------------------------------------------------------------------------------
  585. // TEventHandler::DoUpdate: 
  586. //----------------------------------------------------------------------------------------
  587. #pragma segment MAEvtHandlerRes
  588.  
  589. void TEventHandler::DoUpdate(ChangeID theChange,
  590.                              TObject* changedObject,
  591.                              TObject* changedBy,
  592.                              TDependencySpace* dependencySpace)// Override
  593. {
  594.     TBehavior * aBehavior = GetFirstEnabledBehavior();
  595.     if (aBehavior)
  596.         aBehavior->DoBehaviorUpdate(theChange, changedObject, changedBy, dependencySpace);
  597. }
  598.  
  599. //----------------------------------------------------------------------------------------
  600. // TEventHandler::RetrieveAnEvent: 
  601. //----------------------------------------------------------------------------------------
  602. #pragma segment MAEvtHandlerRes
  603.  
  604. TEvent* TEventHandler::RetrieveAnEvent()
  605. {
  606.     return GetNextHandler() ? GetNextHandler()->RetrieveAnEvent() : NULL;
  607. }
  608.  
  609. //----------------------------------------------------------------------------------------
  610. // TEventHandler::DoKeySelection: 
  611. //----------------------------------------------------------------------------------------
  612. #pragma segment MANonRes
  613.  
  614. void TEventHandler::DoKeySelection(const CStr255&/* selectionString */  )
  615. {
  616.     SubClassResponsibility();
  617. }
  618.  
  619. //----------------------------------------------------------------------------------------
  620. // TEventHandler::SetIdleFreq: 
  621. //----------------------------------------------------------------------------------------
  622. #pragma segment MANonRes
  623.  
  624. void TEventHandler::SetIdleFreq(long newIdleFreq)
  625. {
  626.     fIdleFreq = newIdleFreq;
  627. }
  628.  
  629. //----------------------------------------------------------------------------------------
  630. // TEventHandler::RemoveBehavior: 
  631. //----------------------------------------------------------------------------------------
  632. #pragma segment MANonRes
  633.  
  634. void TEventHandler::RemoveBehavior(TBehavior* theBehavior)
  635. {
  636.     if (fBehavior)
  637.     {
  638.         if (fBehavior == theBehavior)
  639.         {
  640.             fBehavior = theBehavior->GetNextBehavior();
  641.             if (fBehavior)
  642.                 fBehavior->SetPreviousBehavior(NULL);
  643.  
  644.             // remove theBehavior from the linked list
  645.             theBehavior->SetNextBehavior(NULL);
  646.             theBehavior->SetPreviousBehavior(NULL);
  647.             theBehavior->SetOwner(NULL);
  648.         }
  649.         else
  650.             fBehavior->RemoveBehavior(theBehavior);
  651.     }
  652. }
  653.  
  654. //----------------------------------------------------------------------------------------
  655. // TEventHandler::AddBehavior: 
  656. //----------------------------------------------------------------------------------------
  657. #pragma segment MANonRes
  658.  
  659. void TEventHandler::AddBehavior(TBehavior* theBehavior)
  660. {
  661.     if (theBehavior)
  662.     {
  663. #if qDebug
  664.         CBehaviorIterator iter(this);
  665.  
  666.         for (TBehavior * aBehavior = iter.FirstBehavior(); iter.More(); aBehavior = iter.NextBehavior())
  667.             if (aBehavior == theBehavior)
  668.                 ProgramBreak("AddBehavior: Attempting to add a behavior that has already been added.");
  669. #endif
  670.  
  671.         if (fBehavior)
  672.             fBehavior->AppendBehavior(theBehavior);
  673.         else
  674.             fBehavior = theBehavior;
  675.  
  676.         theBehavior->SetOwner(this);            // make this object its owner
  677.     }
  678. }
  679.  
  680. //----------------------------------------------------------------------------------------
  681. // TEventHandler::GetFirstEnabledBehavior: 
  682. //----------------------------------------------------------------------------------------
  683. #pragma segment MAEvtHandlerRes
  684.  
  685. TBehavior* TEventHandler::GetFirstEnabledBehavior() const
  686. {
  687.     return fBehavior ? (fBehavior->IsEnabled() ? fBehavior : fBehavior->GetNextEnabledBehavior()) : NULL;
  688. }
  689.  
  690. //----------------------------------------------------------------------------------------
  691. // TEventHandler::GetBehaviorWithIdentifier: 
  692. //----------------------------------------------------------------------------------------
  693. #pragma segment MAEvtHandlerRes
  694.  
  695. TBehavior* TEventHandler::GetBehaviorWithIdentifier(IDType itsIdentifier)
  696. {
  697.     TBehavior * returnVal = NULL;
  698.  
  699.     CBehaviorIterator iter(this);
  700.  
  701.     for (TBehavior * aBehavior = iter.FirstBehavior(); iter.More(); aBehavior = iter.NextBehavior())
  702.     {
  703.         if (aBehavior->fIdentifier == itsIdentifier)
  704.         {
  705.             returnVal = aBehavior;
  706.             break;
  707.         }
  708.     }
  709.  
  710.     return returnVal;
  711. }
  712.  
  713. //----------------------------------------------------------------------------------------
  714. // TEventHandler::SelectOwner: 
  715. //----------------------------------------------------------------------------------------
  716. #pragma segment MAEvtHandlerRes
  717.  
  718. void TEventHandler::SelectOwner(Boolean select)
  719. {
  720.     CBehaviorIterator iter(this);
  721.  
  722.     for (TBehavior * aBehavior = iter.FirstBehavior(); iter.More(); aBehavior = iter.NextBehavior())
  723.         aBehavior->SelectOwner(select);
  724. }
  725.  
  726. //----------------------------------------------------------------------------------------
  727. // TEventHandler::IsSelected: 
  728. //----------------------------------------------------------------------------------------
  729. #pragma segment MAEvtHandlerRes
  730.  
  731. Boolean TEventHandler::IsSelected()
  732. {
  733.     TBehavior * firstBehavior = GetFirstBehavior();
  734.  
  735.     return firstBehavior ? firstBehavior->IsOwnerSelected() : FALSE;
  736. }
  737.  
  738. //----------------------------------------------------------------------------------------
  739. // TEventHandler::PostAnEvent: 
  740. //----------------------------------------------------------------------------------------
  741. #pragma segment MAEvtHandlerRes
  742.  
  743. void TEventHandler::PostAnEvent(TEvent* event)
  744. {
  745.     if (GetNextHandler())
  746.         GetNextHandler()->PostAnEvent(event);
  747.     else
  748.     {
  749. #if qDebug
  750.         WrLblHexLongint("No one posted the event ", (long)(event));
  751. #endif
  752.  
  753.         if (event->ShouldFreeOnCompletion())
  754.             event = (TEvent *)(FreeIfObject(event));
  755.     }
  756. }
  757.  
  758. //----------------------------------------------------------------------------------------
  759. // TEventHandler::PostCommand: 
  760. //----------------------------------------------------------------------------------------
  761. #pragma segment MAEvtHandlerRes
  762.  
  763. void TEventHandler::PostCommand(TCommand* command)
  764.  
  765. {
  766.     if (command)
  767.     {
  768.         if (GetNextHandler())
  769.             GetNextHandler()->PostCommand(command);
  770.         else
  771.         {
  772. #if qDebug
  773.             WrLblHexLongint("No one posted the command ", (long)(command));
  774.             fprintf(stderr, "\n");
  775. #endif
  776.  
  777.             if (command->ShouldFreeOnCompletion())
  778.                 command = (TCommand *)(FreeIfObject(command));
  779.         }
  780.     }
  781. }
  782.  
  783. //----------------------------------------------------------------------------------------
  784. // TEventHandler::ResignedWindowTarget: 
  785. //----------------------------------------------------------------------------------------
  786. #pragma segment MAEvtHandlerRes
  787.  
  788. void TEventHandler::ResignedWindowTarget()
  789.  
  790. {
  791.     HandleEvent(mResignedWindowTarget, this, NULL);
  792. }
  793.  
  794. //----------------------------------------------------------------------------------------
  795. // TEventHandler::GetWindow: 
  796. //----------------------------------------------------------------------------------------
  797. #pragma segment MAEvtHandlerRes
  798.  
  799. TWindow* TEventHandler::GetWindow() const
  800.  
  801. {
  802.     return NULL;
  803. }
  804.  
  805. //----------------------------------------------------------------------------------------
  806. // TEventHandler::ResignedTarget: 
  807. //----------------------------------------------------------------------------------------
  808. #pragma segment MAEvtHandlerRes
  809.  
  810. void TEventHandler::ResignedTarget()
  811.  
  812. {
  813.     HandleEvent(mResignedTarget, this, NULL);
  814. }
  815.  
  816. //----------------------------------------------------------------------------------------
  817. // TEventHandler::SetTargetSelection: 
  818. //----------------------------------------------------------------------------------------
  819. #pragma segment MAEvtHandlerRes
  820.  
  821. void TEventHandler::SetTargetSelection(Boolean    /* redraw */)
  822. {
  823. }
  824.  
  825. //----------------------------------------------------------------------------------------
  826. // TEventHandler::IsTarget: 
  827. //----------------------------------------------------------------------------------------
  828. #pragma segment MAEvtHandlerRes
  829.  
  830. Boolean TEventHandler::IsTarget()
  831. {
  832.     return this == gDispatcher->GetTarget();
  833. }
  834.  
  835. //----------------------------------------------------------------------------------------
  836. // TEventHandler::Terminate: 
  837. //----------------------------------------------------------------------------------------
  838. #pragma segment MATerminate
  839.  
  840. void TEventHandler::Terminate()
  841. {
  842. }
  843.  
  844. //----------------------------------------------------------------------------------------
  845. // TEventHandler::ReadFrom: 
  846. //----------------------------------------------------------------------------------------
  847. #pragma segment MAReadResource
  848.  
  849. void TEventHandler::ReadFrom(TStream* aStream)
  850. {
  851.     Inherited::ReadFrom(aStream);
  852.  
  853.     fIdentifier = aStream->ReadIDType();
  854.     fEnabled = aStream->ReadBoolean();
  855.     fIdleFreq = aStream->ReadLong();
  856.  
  857.     short numBehaviors = aStream->ReadInteger();
  858.     for (short count = 0; count < numBehaviors; ++count)
  859.     {
  860.         TBehavior * aBehavior = NULL;
  861.  
  862.         if (aStream->ReadStreamObject((TObject * &)aBehavior))
  863.             AddBehavior(aBehavior);
  864. #if qDebugMsg
  865.         else
  866.             ProgramBreak("###Unknown behavior in TEventHandler::ReadFrom: Attempting to create a TBehavior.");
  867. #endif
  868.  
  869.     }
  870. }
  871.  
  872. //----------------------------------------------------------------------------------------
  873. // TEventHandler::WriteTo: 
  874. //----------------------------------------------------------------------------------------
  875. #pragma segment MAWriteResource
  876.  
  877. void TEventHandler::WriteTo(TStream* aStream)
  878. {
  879.     Inherited::WriteTo(aStream);
  880.  
  881.     aStream->WriteIDType(fIdentifier);
  882.     aStream->WriteBoolean(fEnabled);
  883.     aStream->WriteLong(fIdleFreq);
  884.  
  885.     short numBehaviors = 0;
  886.     long numPosition = aStream->GetPosition();    // Remember the position of the
  887.     // count in the stream.
  888.     aStream->WriteInteger(numBehaviors);        // Write initial num behaviors.
  889.     TBehavior * aBehavior = GetFirstBehavior();
  890.     while (aBehavior)
  891.     {
  892.         ++numBehaviors;
  893.         aStream->WriteStreamObject(aBehavior, kStandardObject);
  894.         aBehavior = aBehavior->GetNextBehavior();
  895.     }
  896.  
  897.     if (numBehaviors)                            // if there were any behaviors...
  898.     {
  899.         long currentPosition = aStream->GetPosition();// Remember where we are. 
  900.         aStream->SetPosition(numPosition);        // Go back to position of count. 
  901.         aStream->WriteInteger(numBehaviors);    // Write the count. 
  902.         aStream->SetPosition(currentPosition);    // Go back to where we were. 
  903.     }
  904. }
  905.  
  906. //----------------------------------------------------------------------------------------
  907. // TEventHandler::WantsToBeTarget: 
  908. //----------------------------------------------------------------------------------------
  909. #pragma segment MAEvtHandlerRes
  910.  
  911. Boolean TEventHandler::WantsToBeTarget()
  912.  
  913. {
  914.     return FALSE;
  915. }
  916.  
  917. //----------------------------------------------------------------------------------------
  918. // TEventHandler::WillingToResignTarget: 
  919. //----------------------------------------------------------------------------------------
  920. #pragma segment MAEvtHandlerRes
  921.  
  922. long TEventHandler::WillingToResignTarget()
  923.  
  924. {
  925.     return 0;                                    // kValidValue 
  926. }
  927.  
  928. //----------------------------------------------------------------------------------------
  929. // TEventHandler::KeyEventToComponents: 
  930. //----------------------------------------------------------------------------------------
  931. #pragma segment MAEvtHandlerRes
  932.  
  933. void TEventHandler::KeyEventToComponents(TToolboxEvent* event)
  934.  
  935. {
  936.     if (GetNextHandler())
  937.         GetNextHandler()->KeyEventToComponents(event);
  938.     else
  939.     {
  940.         if ((event->fEventRecord.what == keyDown) || (event->fEventRecord.what == keyUp) || (event->fEventRecord.what == autoKey))
  941.         {
  942.             // Default extractions 
  943.             event->fKeyCode = (unsigned short)(event->fEventRecord.message & keyCodeMask) >> 8;
  944.  
  945.             event->fText = (char)(event->fEventRecord.message & charCodeMask);
  946.             if (MACharacterByteType((Ptr) & event->fText[0], 0, event->fKeyScript) == smFirstByte)
  947.                 event->fText += (char)(event->fEventRecords[1].message & charCodeMask);
  948.         }
  949.     }
  950. }
  951.  
  952. //----------------------------------------------------------------------------------------
  953. // TEventHandler::TargetValidationSucceeded: 
  954. //----------------------------------------------------------------------------------------
  955. #pragma segment MAEvtHandlerRes
  956.  
  957. void TEventHandler::TargetValidationSucceeded()
  958.  
  959. {
  960. }
  961.  
  962. //----------------------------------------------------------------------------------------
  963. // TEventHandler::TargetValidationFailed: 
  964. //----------------------------------------------------------------------------------------
  965. #pragma segment MAEvtHandlerRes
  966.  
  967. void TEventHandler::TargetValidationFailed(long    /* reason */)
  968.  
  969. {
  970. }
  971.  
  972.  
  973. //----------------------------------------------------------------------------------------
  974. // TEventHandler::DoEvent: 
  975. //----------------------------------------------------------------------------------------
  976. #pragma segment MAEvtHandlerRes
  977.  
  978. void TEventHandler::DoEvent(EventNumber eventNumber,
  979.                             TEventHandler* source,
  980.                             TEvent* event)
  981. {
  982.     if (GetNextHandler())
  983.         GetNextHandler()->HandleEvent(eventNumber, source, event);
  984. #if qDebugMsg
  985.     else if (gIntenseDebugging)
  986.     {
  987.         fprintf(stderr, "in TEventHandler.DoHandleEvent: no one handled the event: %1d\n", eventNumber);
  988.         WrLblHexLongint(" From source: ", (long)(source));
  989.         fprintf(stderr, "\n");
  990.         WrLblHexLongint(" Event object: ", (long)(event));
  991.         fprintf(stderr, "\n");
  992.     }
  993. #endif
  994.  
  995. }
  996.  
  997. //----------------------------------------------------------------------------------------
  998. // TEventHandler::HandleEvent: 
  999. //----------------------------------------------------------------------------------------
  1000. #pragma segment MAEvtHandlerRes
  1001.  
  1002. void TEventHandler::HandleEvent(EventNumber eventNumber,
  1003.                                 TEventHandler* source,
  1004.                                 TEvent* event)
  1005. {
  1006.     TBehavior * aBehavior = GetFirstEnabledBehavior();
  1007.     if (aBehavior)
  1008.         aBehavior->DoEvent(eventNumber, source, event);
  1009.     else
  1010.         DoEvent(eventNumber, source, event);
  1011. }
  1012.  
  1013. //----------------------------------------------------------------------------------------
  1014. // End of UEventHandler.cp
  1015.  
  1016. #pragma segment Inline
  1017.  
  1018.